/*********************************************************************************************************************
 * COPYRIGHT NOTICE
 * Copyright (c) 2018,逐飞科技
 * All rights reserved.
 * 技术讨论QQ群：	一群：179029047(已满)
 *					二群：244861897(已满)
 *					三群：824575535
 *
 * 以下所有内容版权均属逐飞科技所有，未经允许不得用于商业用途，
 * 欢迎各位使用并传播本程序，修改内容时必须保留逐飞科技的版权声明。
 *
 * @file			seekfree_esp8266.c
 * @company			成都逐飞科技有限公司
 * @author			逐飞科技(QQ3184284598)
 * @version			查看doc内version文件 版本说明
 * @Software		IAR 8.3 or MDK 5.24
 * @Taobao			https://seekfree.taobao.com/
 * @date			2020-03-25
 * @note			本文件作为IOT开发板 seekfree_esp8266 2.4G WIFI 模块AT指令 API
 ********************************************************************************************************************/
#include "seekfree_esp8266.h"
#include "zf_utick.h"

#define MAX_RECEIVE_WAIT_COUNT					0x03FF0000													// 这里在 150Mhz 下将近 12s 左右 基本足够等待所有配置时间了


volatile static flexcomm_index_list esp8266_flexcomm_select;
volatile static uint16_t esp8266_receive_index = 0x00;														// esp8266 接收数据索引
volatile char esp8266_receive_buffer[MAX_ESP8266_MESSAGE_LEN];												// esp8266 软件接收缓冲区

const char send_crlf_end[2] = {0x0D,0x0A};
static esp8266_ap_message_t ap_message;

//-------------------------------------------------------------------------------------------------------------------
//	@brief		初始化 ESP8266 使用的串口
//	@param		Index			Flex模块号( FC0, FC1, FC2, FC3, FC4, FC5, FC6, FC7 )
//	Sample usage:				esp8266_init(FLEX_COMM0);	// 初始化 FlexCOMM0 为 ESP8266 串口通信功能
//-------------------------------------------------------------------------------------------------------------------
#ifdef IOT_BOARD
void esp8266_init (iot_flexcomm_index_list Index)
#else
void esp8266_init (flexcomm_index_list Index)
#endif
{
	usart_config_t usart_esp8266_config;																	// 新建结构体
	memset((char *)esp8266_receive_buffer, 0, MAX_ESP8266_MESSAGE_LEN);										// 清空数组
	esp8266_flexcomm_select = (flexcomm_index_list)Index;													// 标志当前使用 flexcomm

	zf_usart_get_default_config(&usart_esp8266_config);														// 获取 USART 默认配置
#ifdef IOT_BOARD
	iot_flexcomm_init(Index, FLEX_COMM_USART, &usart_esp8266_config);
#else
	zf_flexcomm_init((flexcomm_index_list)Index, FLEX_COMM_USART, &usart_esp8266_config);
#endif

	zf_usart_interrupt_mode_set
	(
		(flexcomm_index_list)Index,
		USART_INTERRUPT_MODE_RXERR | USART_INTERRUPT_MODE_RXLVL												// 设置中断模式 RXERR 与 RXLVL 中断允许
	);
	zf_usart_interrupt_enable((flexcomm_index_list)Index, esp8266_handler);									// 使能中断
}

//-------------------------------------------------------------------------------------------------------------------
//	@brief		ESP8266 软重启指令
//	@param		Index			Flex模块号( FC0, FC1, FC2, FC3, FC4, FC5, FC6, FC7 )
//	Sample usage:				esp8266_restart(FLEX_COMM0);
//	@note
//-------------------------------------------------------------------------------------------------------------------
#ifdef IOT_BOARD
uint8_t esp8266_restart (iot_flexcomm_index_list Index)
#else
uint8_t esp8266_restart (flexcomm_index_list Index)
#endif
{
	char restart_send_data[9];																				// 发送缓冲
	
	memset(restart_send_data, 0, 9);																		// 清空发送数组
	memcpy(restart_send_data, "AT+RST", 6);																	// 写入发送消息 这里是重启模块
	strncat(restart_send_data, send_crlf_end, 2);															// 拼接包结尾

	delay_ms(2000);																							// 这里是上电后的延时 模块上电会有一大堆无用消息

	esp8266_clear_receive_buffer();																			// 清空数据接收缓冲区

	zf_usart_write_blocking((flexcomm_index_list)Index, (uint8_t *)restart_send_data, 8);					// 发送指令
	if(0x01 != esp8266_receive_message(Index))																// 等待消息回复
		return 0;																							// 重启模块失败
	delay_ms(2000);																							// 略过无法操作的时间段 忽略版本等无用消息

	memset(restart_send_data, 0, 9);																		// 清空发送数组
	memcpy(restart_send_data, "ATE0", 4);																	// 写入发送消息 这里是关闭回显
	strncat(restart_send_data, send_crlf_end, 2);															// 拼接包结尾

	esp8266_clear_receive_buffer();																			// 清空数据接收缓冲区

	zf_usart_write_blocking((flexcomm_index_list)Index, (uint8_t *)restart_send_data, 6);					// 发送指令

	if(0x01 != esp8266_receive_message(Index))																// 等待消息回复
		return 0;																							// 关闭回显功能失败

	return 1;																								// 流程完成
}

//-------------------------------------------------------------------------------------------------------------------
//	@brief		ESP8266 设置模块模式指令
//	@param		Index			Flex模块号( FC0, FC1, FC2, FC3, FC4, FC5, FC6, FC7 )
//	@param		mode			模式  ESP8266_CWMODE_(STATION/SOFTAPSTATION_STATION)
//	Sample usage:				esp8266_set_cwmode(FLEX_COMM0, ESP8266_CWMODE_SOFTAPSTATION_STATION);
//	@note
//-------------------------------------------------------------------------------------------------------------------
#ifdef IOT_BOARD
uint8_t esp8266_set_cwmode (iot_flexcomm_index_list Index, esp8266_cwmode_list mode)
#else
uint8_t esp8266_set_cwmode (flexcomm_index_list Index, esp8266_cwmode_list mode)
#endif
{
	char cwmode_send_data[18];																				// 发送缓冲

	memset(cwmode_send_data, 0, 18);																		// 清空发送数组
	switch(mode)																							// 根据选择模式设置模块
	{
		case ESP8266_CWMODE_STATION:
			memcpy(cwmode_send_data, "AT+CWMODE_CUR=1", 15);												// 写入发送消息 这里是设置模块 station 模式
			break;
		case ESP8266_CWMODE_SOFTAP:
			memcpy(cwmode_send_data, "AT+CWMODE_CUR=2", 15);												// 写入发送消息 这里是设置模块 ap 模式
			break;
		case ESP8266_CWMODE_STATION_STATION:
			memcpy(cwmode_send_data, "AT+CWMODE_CUR=3", 15);												// 写入发送消息 这里是设置模块 station+ap 模式
			break;
	}
	strncat(cwmode_send_data, send_crlf_end, 2);															// 拼接包结尾

	esp8266_clear_receive_buffer();																			// 清空数据接收缓冲区

	zf_usart_write_blocking((flexcomm_index_list)Index, (uint8_t *)cwmode_send_data, 17);					// 发送指令

	if(0x01 != esp8266_receive_message(Index))																// 等待消息回复
		return 0;																							// 设置模块功能失败

	return 1;																								// 流程完成
}

//-------------------------------------------------------------------------------------------------------------------
//	@brief		设置 ESP8266 连接的 AP 的名称
//	@param		name			AP 名
//	@param		size			AP 名长度
//	Sample usage:				esp8266_ap_set_wifi_ssid("WIFI", 4);
//-------------------------------------------------------------------------------------------------------------------
void esp8266_ap_set_wifi_ssid (char *name, uint8_t size)
{
	assert(name != NULL);																					// 断言参数不为空
	assert(size <= 20);																						// 断言长度不超过 20
	memcpy(ap_message.wifi_ssid, name, size);																// 写入对应结构体
	ap_message.wifi_ssid_len = size;																		// 设置长度
}

//-------------------------------------------------------------------------------------------------------------------
//	@brief		设置 ESP8266 连接的 AP 的密码
//	@param		pwd				密码
//	@param		size			密码长度
//	Sample usage:				esp8266_ap_set_wifi_ssid("PASSWORD", 8);
//-------------------------------------------------------------------------------------------------------------------
void esp8266_ap_set_wifi_pwd (char *pwd, uint8_t size)
{
	assert(pwd != NULL);																					// 断言参数不为空
	assert(size <= 20);																						// 断言长度不超过 20
	memcpy(ap_message.wifi_pwd, pwd, size);																	// 写入对应结构体
	ap_message.wifi_pwd_len = size;																			// 设置长度
}

//-------------------------------------------------------------------------------------------------------------------
//	@brief		ESP8266 连接 AP WIFI
//	@param		Index	Flex模块号( FC0, FC1, FC2, FC3, FC4, FC5, FC6, FC7 )
//	Sample usage:				esp8266_ap_connect(FLEX_COMM0);
//	@note
//-------------------------------------------------------------------------------------------------------------------
#ifdef IOT_BOARD
uint8_t esp8266_ap_connect (iot_flexcomm_index_list Index)
#else
uint8_t esp8266_ap_connect (flexcomm_index_list Index)
#endif
{
	uint8_t connect_ap_send_index = 13;																		// 发送数据索引
	char connect_ap_send_data[128];																			// 指令缓冲

	memset(connect_ap_send_data, 0, 128);																	// 清空指令缓冲
	memcpy(connect_ap_send_data, "AT+CWJAP_CUR=", 13);														// 写入指令头

	connect_ap_send_data[connect_ap_send_index++] = 0x22;													// 拼接双引号
	memcpy(&connect_ap_send_data[connect_ap_send_index], ap_message.wifi_ssid, ap_message.wifi_ssid_len);	// 写入 WIFI 名
	connect_ap_send_index = connect_ap_send_index + ap_message.wifi_ssid_len;								// 索引自增
	connect_ap_send_data[connect_ap_send_index++] = 0x22;													// 拼接双引号

	connect_ap_send_data[connect_ap_send_index++] = 0x2C;													// 拼接逗号

	connect_ap_send_data[connect_ap_send_index++] = 0x22;													// 拼接双引号
	memcpy(&connect_ap_send_data[connect_ap_send_index], ap_message.wifi_pwd,  ap_message.wifi_pwd_len);	// 写入密码
	connect_ap_send_index = connect_ap_send_index + ap_message.wifi_pwd_len;								// 索引自增
	connect_ap_send_data[connect_ap_send_index++] = 0x22;													// 拼接双引号

	strncat(connect_ap_send_data, send_crlf_end, 2);														// 拼接包结尾
	connect_ap_send_index += 2;																				// 索引自增

	esp8266_clear_receive_buffer();																			// 清空数据接收缓冲区

	zf_usart_write_blocking((flexcomm_index_list)Index, (uint8_t *)connect_ap_send_data, connect_ap_send_index);			// 发送指令

	if(0x01 != esp8266_receive_message(Index))																// 等待消息回复
		return 0;																							// 连接 AP 失败

	return 1;																								// 流程完成
}

//-------------------------------------------------------------------------------------------------------------------
//	@brief		ESP8266 建立 TCP 连接
//	@param		Index			Flex模块号( FC0, FC1, FC2, FC3, FC4, FC5, FC6, FC7 )
//	@param		ip				目标 IP
//	@param		ip_len			IP长度
//	@param		port			目标端口 同时也是自己的端口
//	@param		port_len		端口长度
//	Sample usage:				esp8266_great_tcp_connect(FLEX_COMM0, "192.168.1.1", 9, 8080, 4);
//	@note
//-------------------------------------------------------------------------------------------------------------------
#ifdef IOT_BOARD
uint8_t esp8266_great_tcp_connect (iot_flexcomm_index_list Index, char *ip, uint8_t ip_len, char *port, uint16_t port_len)
#else
uint8_t esp8266_great_tcp_connect (flexcomm_index_list Index, char *ip, uint8_t ip_len, char *port, uint16_t port_len)
#endif
{
	uint8_t great_tcp_send_index = 12;																		// 发送数据索引
	char great_tcp_send_data[128];																			// 指令缓冲

	memset(great_tcp_send_data, 0, 128);																	// 清空指令缓冲
	memcpy(great_tcp_send_data, "AT+CIPSTART=", 12);														// 写入指令头

	great_tcp_send_data[great_tcp_send_index++] = 0x22;														// 拼接双引号
	memcpy(&great_tcp_send_data[great_tcp_send_index], "TCP", 3);											// 写入 TCP 模式
	great_tcp_send_index = great_tcp_send_index + 3;														// 索引自增
	great_tcp_send_data[great_tcp_send_index++] = 0x22;														// 拼接双引号

	great_tcp_send_data[great_tcp_send_index++] = 0x2C;														// 拼接逗号

	great_tcp_send_data[great_tcp_send_index++] = 0x22;														// 拼接双引号
	memcpy(&great_tcp_send_data[great_tcp_send_index], ip, ip_len);											// 写入目标 IP
	great_tcp_send_index = great_tcp_send_index + ip_len;													// 索引自增
	great_tcp_send_data[great_tcp_send_index++] = 0x22;														// 拼接双引号

	great_tcp_send_data[great_tcp_send_index++] = 0x2C;														// 拼接逗号

	memcpy(&great_tcp_send_data[great_tcp_send_index], port,  port_len);									// 写入目标端口
	great_tcp_send_index = great_tcp_send_index + port_len;													// 索引自增

	strncat(great_tcp_send_data, send_crlf_end, 2);															// 拼接包结尾
	great_tcp_send_index += 2;																				// 索引自增

	esp8266_clear_receive_buffer();																			// 清空数据接收缓冲区

	zf_usart_write_blocking((flexcomm_index_list)Index, (uint8_t *)great_tcp_send_data, great_tcp_send_index);				// 发送指令

	if(0x01 != esp8266_receive_message(Index))																// 等待消息回复
		return 0;																							// 建立 TCP 连接失败

	return 1;																								// 流程完成
}

//-------------------------------------------------------------------------------------------------------------------
//	@brief		ESP8266 建立 UDP 连接
//	@param		Index			Flex模块号( FC0, FC1, FC2, FC3, FC4, FC5, FC6, FC7 )
//	@param		ip				目标 IP
//	@param		ip_len			IP长度
//	@param		port			目标端口 同时也是自己的端口
//	@param		port_len		端口长度
//	Sample usage:				esp8266_great_udp_connect(FLEX_COMM0, "192.168.1.1", 9, 8080, 4);
//	@note
//-------------------------------------------------------------------------------------------------------------------
#ifdef IOT_BOARD
uint8_t esp8266_great_udp_connect (iot_flexcomm_index_list Index, char *ip, uint8_t ip_len, char *port, uint16_t port_len)
#else
uint8_t esp8266_great_udp_connect (flexcomm_index_list Index, char *ip, uint8_t ip_len, char *port, uint16_t port_len)
#endif
{
	uint8_t great_udp_send_index = 12;																		// 发送数据索引
	char great_udp_send_data[128];																			// 指令缓冲

	memset(great_udp_send_data, 0, 128);																	// 清空指令缓冲
	memcpy(great_udp_send_data, "AT+CIPSTART=", 12);														// 写入指令头

	great_udp_send_data[great_udp_send_index++] = 0x22;														// 拼接双引号
	memcpy(&great_udp_send_data[great_udp_send_index], "UDP", 3);											// 写入 TCP 模式
	great_udp_send_index = great_udp_send_index + 3;														// 索引自增
	great_udp_send_data[great_udp_send_index++] = 0x22;														// 拼接双引号

	great_udp_send_data[great_udp_send_index++] = 0x2C;														// 拼接逗号

	great_udp_send_data[great_udp_send_index++] = 0x22;														// 拼接双引号
	memcpy(&great_udp_send_data[great_udp_send_index], ip, ip_len);											// 写入目标 IP
	great_udp_send_index = great_udp_send_index + ip_len;													// 索引自增
	great_udp_send_data[great_udp_send_index++] = 0x22;														// 拼接双引号

	great_udp_send_data[great_udp_send_index++] = 0x2C;														// 拼接逗号

	memcpy(&great_udp_send_data[great_udp_send_index], port,  port_len);									// 写入目标端口
	great_udp_send_index = great_udp_send_index + port_len;													// 索引自增

	great_udp_send_data[great_udp_send_index++] = 0x2C;														// 拼接逗号

	memcpy(&great_udp_send_data[great_udp_send_index], port,  port_len);									// 写入自身端口
	great_udp_send_index = great_udp_send_index + port_len;													// 索引自增

	great_udp_send_data[great_udp_send_index++] = 0x2C;														// 拼接逗号

	memcpy(&great_udp_send_data[great_udp_send_index], "0",  1);											// 写入默认值
	great_udp_send_index = great_udp_send_index + 1;														// 索引自增

	strncat(great_udp_send_data, send_crlf_end, 2);															// 拼接包结尾
	great_udp_send_index += 2;																				// 索引自增

	esp8266_clear_receive_buffer();																			// 清空数据接收缓冲区

	zf_usart_write_blocking((flexcomm_index_list)Index, (uint8_t *)great_udp_send_data, great_udp_send_index);	// 发送指令

	if(0x01 != esp8266_receive_message(Index))																// 等待消息回复
		return 0;																							// 建立 UDP 连接失败

	return 1;																								// 流程完成
}

//-------------------------------------------------------------------------------------------------------------------
//	@brief		ESP8266 查询本地 IP
//	@param		Index			Flex模块号( FC0, FC1, FC2, FC3, FC4, FC5, FC6, FC7 )
//	@param		ip[16]			IP 缓冲区
//	@param		*ip_len			IP 长度指针
//	Sample usage:				esp8266_get_local_ip(FLEX_COMM0, ip_point, iplen_point);
//	@note
//-------------------------------------------------------------------------------------------------------------------
#ifdef IOT_BOARD
uint8_t esp8266_get_local_ip (iot_flexcomm_index_list Index, char ip[16], uint8_t *ip_len)
#else
uint8_t esp8266_get_local_ip (flexcomm_index_list Index, char ip[16], uint8_t *ip_len)
#endif
{
	uint8_t great_udp_send_index = 8;																		// 发送数据索引
	char great_udp_send_data[128];																			// 指令缓冲
	volatile uint8_t receive_index = 0x00;																	// 数据状态
	volatile uint8_t receive_flag = 0x00;																	// 接收状态

	*ip_len = 0;

	memset(great_udp_send_data, 0, 128);																	// 清空指令缓冲
	memcpy(great_udp_send_data, "AT+CIFSR", 8);																// 写入指令头

	strncat(great_udp_send_data, send_crlf_end, 2);															// 拼接包结尾
	great_udp_send_index += 2;																				// 索引自增

	esp8266_clear_receive_buffer();																			// 清空数据接收缓冲区

	zf_usart_write_blocking((flexcomm_index_list)Index, (uint8_t *)great_udp_send_data, great_udp_send_index);	// 发送指令

	if(0x01 != esp8266_receive_message(Index))																// 等待消息回复
		return 0;																							// 查询本地 IP 失败

	while(1)
	{
		if(receive_index != esp8266_receive_index)															// 当前缓冲区有数据
		{
			switch(receive_flag)																			// 按照状态进行跳转
			{
				case 0x00:																					// 处于未接受到 OK 指令头的状态
					if(strncmp((const char *)(&esp8266_receive_buffer[receive_index]), "STAIP", 5) == 0)	// 获取 STAIP 字段
					{
						receive_index += 5;
						receive_flag = 0x01;																// 状态跳转
					}
					break;
				case 0x01:																					// 处于接受到一个 O 的情况
					if(esp8266_receive_buffer[receive_index] == 0x22)										// 获取一个 K 字节
					{
						receive_flag = 0x02;																// 状态跳转 结束
					}
					else																					// 接收的不是 OK 指令
					{
						receive_flag = 0x00;																// 状态跳转
					}
					break;
				case 0x02:																					// 处于接受到一个 O 的情况
					if(esp8266_receive_buffer[receive_index] == 0x22)										// 获取一个 K 字节
					{
						memcpy(ip, (const char *)&esp8266_receive_buffer[receive_index-(*ip_len)], *ip_len);
						return 1;
					}
					else																					// 接收的不是 OK 指令
					{
						*ip_len += 1;																// 状态跳转
					}
					break;
			}
			receive_index ++;
		}
		else
			return 0;																								// 流程完成
	}
}

//-------------------------------------------------------------------------------------------------------------------
//	@brief		ESP8266 发送消息
//	@param		Index			Flex模块号( FC0, FC1, FC2, FC3, FC4, FC5, FC6, FC7 )
//	@param		data			数据缓冲区
//	@param		data_len		数据长度
//	Sample usage:				esp8266_send_message(FLEX_COMM0, "192.168.1.1", 9);
//	@note
//-------------------------------------------------------------------------------------------------------------------
#ifdef IOT_BOARD
uint8_t esp8266_send_message (iot_flexcomm_index_list Index, char *data, uint32_t data_len)
#else
uint8_t esp8266_send_message (flexcomm_index_list Index, char *data, uint32_t data_len)
#endif
{
	uint8_t send_message_send_index = 11;																	// 发送数据索引
	char send_message_send_data[256+11];																	// 指令缓冲

	assert(data != NULL);																					// 断言参数不为空
	assert(data_len <= MAX_ESP8266_MESSAGE_LEN);															// 断言长度不超过 最长消息

	memset(send_message_send_data, 0, 256+11);																// 清空指令缓冲
	memcpy(send_message_send_data, "AT+CIPSEND=", 11);														// 写入指令头

	if( data_len > 999 )																					// 如果数据长度超过 1000
		send_message_send_data[send_message_send_index++] = ((data_len/1000) + 0x30);						// 写入千位
	if( data_len > 99 )																						// 数据长度超过 100
		send_message_send_data[send_message_send_index++] = ((data_len%1000/100) + 0x30);					// 写入百位
	if( data_len > 9 )																						// 数据长度超过 10
		send_message_send_data[send_message_send_index++] = ((data_len%100/10) + 0x30);						// 写入十位
	send_message_send_data[send_message_send_index++] = ((data_len%10) + 0x30);								// 写入个位

	strncat(send_message_send_data, send_crlf_end, 2);														// 拼接包结尾
	send_message_send_index += 2;																			// 索引自增

	esp8266_clear_receive_buffer();																			// 清空数据接收缓冲区

	zf_usart_write_blocking((flexcomm_index_list)Index, (uint8_t *)send_message_send_data, send_message_send_index);		// 发送指令

	if(0x01 != esp8266_receive_message(Index))																// 等待消息回复
		return 0;																							// 连接是否有效 是否可以发送

	esp8266_clear_receive_buffer();																			// 清空数据接收缓冲区

	zf_usart_write_blocking((flexcomm_index_list)Index, (uint8_t *)data, data_len);							// 发送数据

	if(0x01 != esp8266_receive_message(Index))																// 等待消息回复
		return 0;																							// 发送是否成功

	return 1;																								// 流程完成
}

//-------------------------------------------------------------------------------------------------------------------
//	@brief		ESP8266 消息查验
//	@param		Index			Flex模块号( FC0, FC1, FC2, FC3, FC4, FC5, FC6, FC7 )
//	@return						0 - 消息回环错误 未收到 OK		1 - 消息回环完成
//	Sample usage:				esp8266_receive_message(FLEX_COMM0);
//	@note
//-------------------------------------------------------------------------------------------------------------------
#ifdef IOT_BOARD
uint8_t esp8266_receive_message (iot_flexcomm_index_list Index)
#else
uint8_t esp8266_receive_message (flexcomm_index_list Index)
#endif
{
	// 为了防止优化等级提高后导致的各种问题请务必使用 volatile 修饰
	volatile uint8_t receive_flag = 0x00;																	// 接收状态
	volatile uint8_t receive_index = 0x00;																	// 数据状态
	volatile uint32_t timer_out_count = 0x0000;																// 超时计数

	while(1)
	{
		if(receive_index != esp8266_receive_index)															// 当前缓冲区有数据
		{
			switch(receive_flag)																			// 按照状态进行跳转
			{
				case 0x00:																					// 处于未接受到 OK 指令头的状态
					if(esp8266_receive_buffer[receive_index] == 0x4F)										// 获取一个 O 字节
					{
						receive_flag = 0x01;																// 状态跳转
					}
					break;
				case 0x01:																					// 处于接受到一个 O 的情况
					if(esp8266_receive_buffer[receive_index] == 0x4B)										// 获取一个 K 字节
					{
						receive_flag = 0x80;																// 状态跳转 结束
					}
					else																					// 接收的不是 OK 指令
					{
						receive_flag = 0x00;																// 状态跳转
					}
					break;
			}
			timer_out_count = 0;
			receive_index ++;
		}
		if(receive_flag == 0x80)
			return 1;
		timer_out_count ++;
		if(timer_out_count > MAX_RECEIVE_WAIT_COUNT)														// 从发送命令到收到答复将近有 300us 的间隔
		{
			return 0;
		}
	}
}

//-------------------------------------------------------------------------------------------------------------------
//	@brief		ESP8266 清空消息队列
//	Sample usage:				esp8266_clear_receive_buffer();
//	@note
//-------------------------------------------------------------------------------------------------------------------
void esp8266_clear_receive_buffer (void)
{
	memset((char *)esp8266_receive_buffer, 0, MAX_ESP8266_MESSAGE_LEN);										// 清空数据接收缓冲区
	esp8266_receive_index = 0;																				// 清空索引
}

//-------------------------------------------------------------------------------------------------------------------
//	@brief		ESP8266 读取消息队列
//	@param		receive_buffer	读取缓冲区
//	@return						0 - 没有消息	n -  消息长度
//	Sample usage:				uint8_t len = esp8266_read_receive_buffer(&data_buffer);
//	@note
//-------------------------------------------------------------------------------------------------------------------
uint16_t esp8266_read_receive_buffer (char *receive_buffer)
{
	uint32_t data_len = 0;

	assert(receive_buffer != NULL);

	if(esp8266_receive_index > 0)
	{
		memcpy(receive_buffer, (void *)esp8266_receive_buffer, esp8266_receive_index);
		return esp8266_receive_index;
	}
	return 0;
}

//-------------------------------------------------------------------------------------------------------------------
//	@brief		ESP8266 串口中断服务函数
//	@note
//-------------------------------------------------------------------------------------------------------------------
void esp8266_handler (void)
{
	if(USART_FIFO_STATUS_RXNOTEMPTY & usart_index[esp8266_flexcomm_select]->FIFOSTAT)						// RX 缓存不为空	
	{
		esp8266_receive_buffer[esp8266_receive_index++] =
			(uint8_t)usart_index[esp8266_flexcomm_select]->FIFORD;											// 读取 FIFO 中 1byte 数据
		if(esp8266_receive_index == MAX_ESP8266_MESSAGE_LEN)
			esp8266_receive_index = 0;
	}
	else if(USART_FIFO_STATUS_RXERR & usart_index[esp8266_flexcomm_select]->FIFOSTAT)						// RX 出错
	{
		zf_usart_set_fifo_status(esp8266_flexcomm_select, 0x00000003);										// 清空报错
	}
}
